classdef ModelDataTransformer
    % MODELDATATRANSFORMER 模型数据转换器（静态工具类）
    % 基于DO-178规则第4条（架构分离原则）设计
    % 负责处理模型数据在不同格式之间的转换
    %
    % 功能：
    %   - 模型列表转换为GUI表格格式
    %   - 模型树数据转换
    %   - 模型信息格式化
    %   - 数据验证和格式化
    %
    % 设计原则：
    %   - 静态工具类：所有方法都是静态的，无状态
    %   - 单一职责：只负责数据转换，不包含业务逻辑
    %   - 可复用：所有方法独立，可以在不同场景复用
    %   - 明确错误：遵循规则第2条，明确报告转换错误
    %
    % 使用示例：
    %   % 转换模型列表为表格数据
    %   modelList = {'Model1', 'Model2', 'Model3'};
    %   tableData = ModelDataTransformer.convertModelListToTable(modelList);
    %   
    %   % 格式化模型信息
    %   modelInfo = service.getModelInfo('MyModel');
    %   formattedInfo = ModelDataTransformer.formatModelInfo(modelInfo);
    %
    % 作者: MBD Platform Team
    % 日期: 2025-10-05
    % 遵循DO-178标准
    
    methods (Static)
        %% ==================== 模型列表转换 ====================
        
        function tableData = convertModelListToTable(modelList, includeStatus)
            % 将模型列表转换为GUI表格格式
            % 输入：
            %   modelList - 模型名称的cell array
            %   includeStatus - (可选) 是否包含状态列，默认true
            % 输出：
            %   tableData - cell array，每行包含 [序号, 模型名, 路径, 状态, 大小, 修改日期]
            % 基于规则第2条：明确报告错误
            
            if nargin < 2
                includeStatus = true;
            end
            
            if isempty(modelList)
                fprintf('⚠️ 模型列表为空\n');
                tableData = {};
                return;
            end
            
            try
                numModels = length(modelList);
                
                if includeStatus
                    % 6列：序号、模型名、路径、状态、大小、修改日期
                    tableData = cell(numModels, 6);
                else
                    % 3列：序号、模型名、路径
                    tableData = cell(numModels, 3);
                end
                
                for i = 1:numModels
                    modelName = modelList{i};
                    tableData{i, 1} = i; % 序号
                    tableData{i, 2} = modelName; % 模型名
                    
                    % 获取模型路径
                    modelPath = which(modelName);
                    if isempty(modelPath)
                        tableData{i, 3} = '未找到';
                        if includeStatus
                            tableData{i, 4} = '❌ 不存在';
                            tableData{i, 5} = '-';
                            tableData{i, 6} = '-';
                        end
                        continue;
                    end
                    
                    tableData{i, 3} = modelPath;
                    
                    if includeStatus
                        % 获取模型状态
                        if bdIsLoaded(modelName)
                            tableData{i, 4} = '✅ 已打开';
                        else
                            tableData{i, 4} = '⚪ 未打开';
                        end
                        
                        % 获取文件大小和修改日期
                        try
                            fileInfo = dir(modelPath);
                            tableData{i, 5} = ModelDataTransformer.formatFileSize(fileInfo.bytes);
                            tableData{i, 6} = fileInfo.date;
                        catch
                            tableData{i, 5} = '-';
                            tableData{i, 6} = '-';
                        end
                    end
                end
                
                fprintf('✅ 成功转换 %d 个模型为表格格式\n', numModels);
                
            catch ME
                error('ModelDataTransformer:ConvertFailed', ...
                    '模型列表转换失败: %s', ME.message);
            end
        end
        
        function treeData = convertModelListToTree(modelList)
            % 将模型列表转换为树形结构数据
            % 输入：
            %   modelList - 模型名称的cell array
            % 输出：
            %   treeData - 树形结构的cell array
            
            if isempty(modelList)
                treeData = {};
                return;
            end
            
            try
                % 按字母顺序排序
                modelList = sort(modelList);
                
                % 构建树形结构
                treeData = cell(length(modelList), 1);
                for i = 1:length(modelList)
                    treeData{i} = struct( ...
                        'name', modelList{i}, ...
                        'type', 'model', ...
                        'icon', '📦', ...
                        'children', {});
                end
                
            catch ME
                error('ModelDataTransformer:ConvertTreeFailed', ...
                    '模型树转换失败: %s', ME.message);
            end
        end
        
        %% ==================== 模型信息格式化 ====================
        
        function formattedInfo = formatModelInfo(modelInfo)
            % 格式化模型信息为用户友好的显示格式
            % 输入：
            %   modelInfo - 模型信息结构体（来自ModelManagementService.getModelInfo）
            % 输出：
            %   formattedInfo - 格式化后的信息cell array（用于显示）
            
            if isempty(modelInfo)
                formattedInfo = {};
                return;
            end
            
            try
                formattedInfo = {};
                formattedInfo{end+1} = sprintf('📦 模型名称: %s', modelInfo.name);
                formattedInfo{end+1} = sprintf('📂 文件路径: %s', modelInfo.path);
                formattedInfo{end+1} = sprintf('📁 所在目录: %s', modelInfo.folder);
                formattedInfo{end+1} = sprintf('💾 文件大小: %s', ...
                    ModelDataTransformer.formatFileSize(modelInfo.size));
                formattedInfo{end+1} = sprintf('📅 修改日期: %s', modelInfo.dateModified);
                
                if ~isempty(modelInfo.checksum)
                    formattedInfo{end+1} = sprintf('🔐 校验和: %s', modelInfo.checksum);
                end
                
                if modelInfo.isLoaded
                    formattedInfo{end+1} = '✅ 状态: 已打开';
                else
                    formattedInfo{end+1} = '⚪ 状态: 未打开';
                end
                
            catch ME
                error('ModelDataTransformer:FormatInfoFailed', ...
                    '格式化模型信息失败: %s', ME.message);
            end
        end
        
        function sizeStr = formatFileSize(bytes)
            % 格式化文件大小为可读格式
            % 输入：
            %   bytes - 文件大小（字节）
            % 输出：
            %   sizeStr - 格式化后的大小字符串（如 "1.5 MB"）
            
            if bytes < 1024
                sizeStr = sprintf('%d B', bytes);
            elseif bytes < 1024^2
                sizeStr = sprintf('%.1f KB', bytes / 1024);
            elseif bytes < 1024^3
                sizeStr = sprintf('%.1f MB', bytes / 1024^2);
            else
                sizeStr = sprintf('%.2f GB', bytes / 1024^3);
            end
        end
        
        function statusStr = formatModelStatus(modelName)
            % 格式化模型状态
            % 输入：
            %   modelName - 模型名称
            % 输出：
            %   statusStr - 状态字符串
            
            try
                if bdIsLoaded(modelName)
                    statusStr = '✅ 已打开';
                else
                    statusStr = '⚪ 未打开';
                end
            catch
                statusStr = '❌ 错误';
            end
        end
        
        %% ==================== 模型依赖数据转换 ====================
        
        function tableData = convertDependenciesToTable(dependencies)
            % 将依赖关系数据转换为表格格式
            % 输入：
            %   dependencies - 依赖关系结构体数组
            % 输出：
            %   tableData - 表格数据cell array
            
            if isempty(dependencies)
                fprintf('⚠️ 依赖关系为空\n');
                tableData = {};
                return;
            end
            
            try
                numDeps = length(dependencies);
                % 4列：序号、依赖名称、类型、路径
                tableData = cell(numDeps, 4);
                
                for i = 1:numDeps
                    dep = dependencies(i);
                    tableData{i, 1} = i;
                    tableData{i, 2} = ModelDataTransformer.getFieldValue(dep, 'name', '未知');
                    tableData{i, 3} = ModelDataTransformer.getFieldValue(dep, 'type', '未知');
                    tableData{i, 4} = ModelDataTransformer.getFieldValue(dep, 'path', '未知');
                end
                
                fprintf('✅ 成功转换 %d 个依赖关系\n', numDeps);
                
            catch ME
                error('ModelDataTransformer:ConvertDependenciesFailed', ...
                    '依赖关系转换失败: %s', ME.message);
            end
        end
        
        %% ==================== 数据验证 ====================
        
        function isValid = validateModelListData(modelList)
            % 验证模型列表数据是否有效
            % 输入：
            %   modelList - 模型列表
            % 输出：
            %   isValid - 是否有效
            
            isValid = false;
            
            if isempty(modelList)
                fprintf('⚠️ 模型列表为空\n');
                return;
            end
            
            if ~iscell(modelList)
                fprintf('❌ 模型列表必须是cell array\n');
                return;
            end
            
            % 检查每个元素是否为字符串
            for i = 1:length(modelList)
                if ~ischar(modelList{i})
                    fprintf('❌ 模型列表第 %d 个元素不是字符串\n', i);
                    return;
                end
            end
            
            isValid = true;
        end
        
        function isValid = validateTableData(tableData, expectedColumns)
            % 验证表格数据是否有效
            % 输入：
            %   tableData - 表格数据cell array
            %   expectedColumns - 期望的列数
            % 输出：
            %   isValid - 是否有效
            
            isValid = false;
            
            if isempty(tableData)
                fprintf('⚠️ 表格数据为空\n');
                return;
            end
            
            if ~iscell(tableData)
                fprintf('❌ 表格数据必须是cell array\n');
                return;
            end
            
            % 检查列数
            [~, numCols] = size(tableData);
            if numCols ~= expectedColumns
                fprintf('❌ 表格数据必须有%d列（实际%d列）\n', expectedColumns, numCols);
                return;
            end
            
            isValid = true;
        end
        
        %% ==================== 辅助方法 ====================
        
        function value = getFieldValue(structData, fieldName, defaultValue)
            % 安全地获取结构体字段值
            % 输入：
            %   structData - 结构体
            %   fieldName - 字段名
            %   defaultValue - 默认值
            % 输出：
            %   value - 字段值或默认值
            
            if isfield(structData, fieldName)
                value = structData.(fieldName);
                if isempty(value)
                    value = defaultValue;
                end
            else
                value = defaultValue;
            end
        end
        
        function summary = generateModelListSummary(modelList)
            % 生成模型列表摘要信息
            % 输入：
            %   modelList - 模型列表
            % 输出：
            %   summary - 摘要字符串
            
            if isempty(modelList)
                summary = '未检测到任何模型';
                return;
            end
            
            try
                numModels = length(modelList);
                numLoaded = 0;
                
                for i = 1:numModels
                    if bdIsLoaded(modelList{i})
                        numLoaded = numLoaded + 1;
                    end
                end
                
                summary = sprintf('📊 模型统计: 共 %d 个模型，其中 %d 个已打开', ...
                    numModels, numLoaded);
                
                fprintf('%s\n', summary);
                
            catch ME
                summary = sprintf('生成摘要失败: %s', ME.message);
            end
        end
        
        function filteredList = filterModelList(modelList, keyword)
            % 根据关键字过滤模型列表
            % 输入：
            %   modelList - 模型列表
            %   keyword - 过滤关键字（空则不过滤）
            % 输出：
            %   filteredList - 过滤后的列表
            
            if isempty(modelList)
                filteredList = {};
                return;
            end
            
            if nargin < 2 || isempty(keyword)
                filteredList = modelList;
                return;
            end
            
            try
                filteredList = {};
                keyword = lower(keyword);
                
                for i = 1:length(modelList)
                    modelName = lower(modelList{i});
                    if contains(modelName, keyword)
                        filteredList{end+1} = modelList{i};
                    end
                end
                
                fprintf('✅ 模型过滤完成: 从 %d 个模型筛选出 %d 个\n', ...
                    length(modelList), length(filteredList));
                
            catch ME
                error('ModelDataTransformer:FilterFailed', ...
                    '模型列表过滤失败: %s', ME.message);
            end
        end
        
        function sortedList = sortModelList(modelList, sortBy)
            % 对模型列表进行排序
            % 输入：
            %   modelList - 模型列表
            %   sortBy - 排序方式：'name'（名称，默认）, 'size'（大小）, 'date'（修改日期）
            % 输出：
            %   sortedList - 排序后的列表
            
            if isempty(modelList)
                sortedList = {};
                return;
            end
            
            if nargin < 2
                sortBy = 'name';
            end
            
            try
                switch lower(sortBy)
                    case 'name'
                        % 按名称排序
                        sortedList = sort(modelList);
                        
                    case 'size'
                        % 按文件大小排序
                        sizes = zeros(length(modelList), 1);
                        for i = 1:length(modelList)
                            modelPath = which(modelList{i});
                            if ~isempty(modelPath)
                                fileInfo = dir(modelPath);
                                sizes(i) = fileInfo.bytes;
                            end
                        end
                        [~, idx] = sort(sizes, 'descend');
                        sortedList = modelList(idx);
                        
                    case 'date'
                        % 按修改日期排序
                        dates = zeros(length(modelList), 1);
                        for i = 1:length(modelList)
                            modelPath = which(modelList{i});
                            if ~isempty(modelPath)
                                fileInfo = dir(modelPath);
                                dates(i) = datenum(fileInfo.date);
                            end
                        end
                        [~, idx] = sort(dates, 'descend');
                        sortedList = modelList(idx);
                        
                    otherwise
                        fprintf('⚠️ 不支持的排序方式: %s，使用默认排序（按名称）\n', sortBy);
                        sortedList = sort(modelList);
                end
                
            catch ME
                error('ModelDataTransformer:SortFailed', ...
                    '模型列表排序失败: %s', ME.message);
            end
        end
    end
end




